#include<iostream>
#include<string>
#include<stdlib.h>
#include<math.h>
#include "swap.h"
using namespace std;
#pragma region 第一个程序
/*
int main()
{
	//第一个程序C++
	cout << "Hello World" << endl;
	system("pause");
	return 0;
}
*/

#pragma endregion
#pragma region 定义变量
/*
int main()
{
	//变量定义
	int a = 10;
	cout << "A= " << a << endl;
	system("pause");
	return 0;
}
*/
#pragma endregion
#pragma region 常量
/*
#define day 7 //定义的宏常量
int main()
{
	cout << "一周里总共有" << day << "天" << endl;
	//day = 8;//报错，宏常量不可以修改
	//2.Const修饰
	const int month = 12;
	cout << "一年里总共有" << month << "个月份" << endl;
	//month = 24;//常量是不可以修改的
	system("pause");
	return 0;
}
*/
#pragma endregion
#pragma region 1.5关键字
/*
C++关键字如下：

| asm | do | if | return | typedef  |
| ---------- | ------------ | ---------------- | ---------- - | -------- |
| auto | double | inline | short | typeid   |
| bool | dynamic_cast | int | signed | typename |
| break | else | long | sizeof | union    |
| case | enum | mutable | static | unsigned |
| catch | explicit | namespace | static_cast | using    |
| char | export | new | struct | virtual  |
| class | extern | operator         | switch | void     |
| const | false | private | template | volatile |
| const_cast | float | protected | this | wchar_t  |
| continue | for | public | throw | while    |
| default | friend | register | true        |          |
| delete | goto | reinterpret_cast | try         |          |

`提示：在给变量或者常量起名称时候，不要用C++得关键字，否则会产生歧义。`
*/

#pragma endregion
#pragma region sizeof关键字
//利用sizeof关键字可以==统计数据类型所占内存大小
/*
int main()
{
	cout << "short 类型所占用的内存空间为 " << sizeof(int) << endl;
	cout << "long类型所占用的内存空间为: "<< sizeof(long) << endl;
	cout << "long long 类型所占的内存空间: "<< sizeof(long long) << endl;
	system("pause");
	return 0;
}
*/
#pragma endregion
#pragma region 2.3实数（浮点型）
//单精度：float 双精度:double
/*
int main()
{
	float f1 = 3.145f;
	double d1 = 2.13474;
	cout <<"单精度数值: "<< f1 << endl;
	cout << "双精度数值: " << d1 << endl;

	//科学计数法
	float f2 = 3e2; //3*10^2
	float f3 = 3e-2;//3*0.1^2;
	cout << "科学计数当精度值：" << f2 << endl;
	cout << "科学计数当前精度 :" << f3 << endl;
	system("pause");
	return 0;
}
*/
#pragma endregion
#pragma region 2.4字符 字符型变量用于显示单个字符
//- C和C++中字符型变量只占用==1个字节==。
// 字符型变量并不是把字符本身放到内存中存储，而是将对应的ASCII编码放入到存储单元
/*
int main()
{
	char ch = 'a';
	cout << ch << endl;
	cout << sizeof(char) << endl; //1个字符
	cout << (int)ch << endl;//查看字符a对应的Ascii码 97
	char b = 98; //可以直接用ASCII给字符型变量赋值
	cout << b << endl;//打印出来'b'字符
	system("puase");
	return 0;
}
*/

#pragma endregion
/*
ASCII 码大致由以下**两部分组**成：
* ASCII 非打印控制字符： ASCII 表上的数字 **0-31** 分配给了控制字符，用于控制像打印机等一些外围设备。
* ASCII 打印字符：数字 **32-126** 分配给了能在键盘上找到的字符，当查看或打印文档时就会出现。
*/
#pragma region 2.6字符串 两种风格 C风格:char 变量名[] = "字符串值" C++风格:string  变量名 = "字符串值"
/*
int main()
{
	cout<<"---------C语言风格------" << endl;
	char str[] = "hello world";
	cout << str << endl;
	cout << "---------C++语言风格------" << endl;
	string str1 = "C++字符串";
	cout << str1 << endl;
	system("pause");
	return 0;
}
//注意：C++风格字符串，需要加入头文件==#include\<string>==
*/

#pragma endregion
#pragma region 2.8数据的输入 cin
/*
int main()
{
	int a = 0;
	cout << "请输入整型变量:" << endl;
	cin >> a;
	cout << a << endl;

	double d = 0;
	cout << "请输入浮点型变量" << endl;
	cin >> d;
	cout << d << endl;

	char ch = 0;
	cout << "请输入字符型变量" << endl;
	cin >> ch;
	cout << ch << endl;

	string str;
	cout << "请输入字符串类型变量" << endl;
	cin >> str;
	cout << str << endl;

	bool flag = true;
	cout << "请输入布尔变量" << endl;
	cin >> flag;
	cout << flag << endl;
	system("pause");

	return EXIT_SUCCESS;//系统宏常量为0；
}
*/
#pragma endregion
#pragma region 运算符
/*

*/
//| 算术运算符 | 用于处理四则运算                       |
//| 赋值运算符 | 用于将表达式的值赋给变量               |
//| 比较运算符 | 用于表达式的比较，并返回一个真值或假值 |
//| 逻辑运算符 | 用于根据表达式的值返回真值或假值 |
//| **运算符 * *| **术语 * *| **示例 * *| **结果 * *|
//| ---------- | ---------- | ---------- - | -------- - |
//| +| 正号 | +3 | 3         |
//| -| 负号 | -3 | -3        |
//| +| 加 | 10 + 5 | 15        |
//| -| 减 | 10 - 5 | 5         |
//| *| 乘 | 10 * 5 | 50        |
//| /          | 除 | 10 / 5 | 2         |
//| % | 取模(取余) | 10 % 3 | 1         |
//| ++ | 前置递增 | a = 2; b = ++a; | a = 3; b = 3; |
//| ++ | 后置递增 | a = 2; b = a++; | a = 3; b = 2; |
//| -- | 前置递减 | a = 2; b = --a; | a = 1; b = 1; |
//| -- | 后置递减 | a = 2; b = a--; | a = 1; b = 2; |

//赋值运算符包括以下几个符号：
//
//| **运算符 * *| **术语 * *| **示例 * *| **结果 * *|
//| ---------- | -------- | ---------- | -------- - |
//| = | 赋值 | a = 2; b = 3; | a = 2; b = 3; |
//| += | 加等于 | a = 0; a += 2; | a = 2;      |
//| -= | 减等于 | a = 5; a -= 3; | a = 2;      |
//| *= | 乘等于 | a = 2; a *= 2; | a = 4;      |
//| /= | 除等于 | a = 4; a /= 2; | a = 2;      |
//| %= | 模等于 | a = 3; a % 2; | a = 1; |

//比较运算符有以下符号：
//
//| **运算符 * *| **术语 * *| **示例 * *| **结果 * *|
//| ---------- | -------- | -------- | -------- |
//| ==         | 相等于 | 4 == 3 | 0        |
//| !=         | 不等于 | 4 != 3 | 1        |
//| < | 小于 | 4 < 3 | 0        |
//	| \ > | 大于 | 4 > 3 | 1        |
//	| <=         | 小于等于 | 4 <= 3 | 0        |
//	| \>=        | 大于等于 | 4 >= 1 | 1 |
//
//逻辑运算符有以下符号：
//
//| **运算符 * *| **术语 * *| **示例 * *| **结果 * *|
//| ---------- | -------- | -------- | -------------------------------------------------------- |
//| !| 非 | !a | 如果a为假，则!a为真；  如果a为真，则!a为假。             |
//| && | 与 | a && b | 如果a和b都为真，则结果为真，否则为假。                   |
//| \ | \|       | 或 | a \ | \ | b | 如果a和b有一个为真，则结果为真，二者都为假时，结果为假。 |
#pragma endregion
#pragma region 三目运算符
/*
int main()
{
	int a = 0;
	int b = 20;
	int c = 30;
	c = a > b ? a : b;
	cout << c << endl;
	(a > b ? a : b) = 100; //C++中三目运算符返回的是变量,可以继续赋值 C#不可以
	cout << "a= " << a << endl;
	cout << "b= " << b << endl;
	cout << "c= " << c << endl;
	system("Pause");
	return 0;
}
*/
#pragma endregion
#pragma region question 三位数的水仙花数
/*
int main()
{
	int num = 101;
	do
	{
		if (num > 100)
		{
			int g = num % 10;
			int s = num / 10 % 10;
			int b = num / 100 % 10;

			int gg = pow(g,3);
			int ss = pow(s, 3);
			int bb = pow(b, 3);

			int ret = gg+ss+bb;
			if (ret == num)
			{
				cout << "打印水仙花数 ：" << num << endl;
			}
			num++;
		}

	} while (num < 999);
	system("pause");
	return 0;
}
*/
//打印水仙花数 ：153  :1^3+5^3+3^3=153;
//打印水仙花数 ：370
//打印水仙花数 ：371
//打印水仙花数 ：407
#pragma endregion
#pragma region 嵌套循环，实现九九乘法表
/*
int main()
{
	for (int i = 0; i <= 9; i++)
	{
		for (int j = 0; j <= 9; j++)
		{
			cout << i << "*" << j << "=" << i * j;
			cout << "    ";
		}
		cout << endl;
	}
	return 0;
}
*/
#pragma endregion

#pragma region 函数的声明
// 函数的**声明可以多次**，但是函数的**定义只能有一次

/*
int max(int a, int b);
int max(int a, int b);
int max(int a, int b)
{
	return a > b ? a : b;
}
int main()
{
	int ret = max(5, 9);
	cout << ret << endl;
	return 0;
}
*/

#pragma endregion

#pragma region 函数的头文件
//函数分文件编写一般有4个步骤
//
//1. 创建后缀名为.h的头文件
//2. 创建后缀名为.cpp的源文件
//3. 在头文件中写函数的声明
//4. 在源文件中写函数的定义
//include "swap.h" 定义头文件
/*
void swap(int a, int b)
{
	int temp = a;
	a = b;
	b = temp;

	cout << "a= " << a << endl;
	cout << "b= " << b << endl;
}
int main()
{
	int a = 200;
	int b = 300;
	swap(a, b);
	system("pause");
	return 0;
}
*/

#pragma endregion

#pragma region 指针的访问
//可以通过指针间接访问内存
//* 内存编号是从0开始记录的，一般用十六进制数字表示
//* 可以利用指针变量保存地址
/*
int main()
{
	int a = 13;
	int* p;

	p = &a;
	cout << p << endl;
	cout << &a << endl;

	cout << "*p= " << *p << endl;
	system("pause");
	return 0;
}
*/

#pragma endregion

/*
指针变量和普通变量的区别

* 普通变量存放的是数据,指针变量存放的是地址
* 指针变量可以通过" * "操作符，操作指针变量指向的内存空间，这个过程称为解引用

> 总结1： 我们可以通过 & 符号 获取变量的地址

> 总结2：利用指针可以记录地址

> 总结3：对指针变量解引用，可以操作指针指向的内存

*/

#pragma region 指针所占的内存空间
/*
int main()
{
	int a = 10;
	int* p;
	p = &a;

	cout << *p << endl;
	cout <<"p的内存大小 :"<< sizeof(p) << endl;
	cout << sizeof(char*) << endl;
	cout << sizeof(float*) << endl;
	cout << sizeof(double*) << endl;
	system("pause");
	return 0;
	//总结：所有指针类型在32位操作系统下是4个字节
}
*/
#pragma endregion

#pragma region 空指针
/*
int main()
{
	int* p = NULL;//指针变量p指向内存地址编号为0的空间
	//访问空指针报错 
	//内存编号0 ~255为系统占用内存，不允许用户访问
	cout << *p << endl;
	system("pause");
	return 0;
}

*/
#pragma endregion

#pragma region 野指针
/*
int main()
{
	////指针变量p指向内存地址编号为0x1100的空间
	int* p = (int*)0x1100;
	//访问野指针报错 
	cout << *p << endl;
	system("pause");
	return 0;
	//总结：空指针和野指针都不是我们申请的空间，因此不要访问。
}
*/

#pragma endregion

#pragma region const修饰指针
//const修饰指针有三种情况
//1. const修饰指针-- - 常量指针
//2. const修饰常量-- - 指针常量
//3. const即修饰指针，又修饰常量
//技巧：看const右侧紧跟着的是指针还是常量, 是指针就是常量指针，是常量就是指针常量
int main() {

	int a = 10;
	int b = 10;

	//const修饰的是指针，指针指向可以改，指针指向的值不可以更改
	const int* p1 = &a;
	p1 = &b; //正确
	//*p1 = 100;  报错


	//const修饰的是常量，指针指向不可以改，指针指向的值可以更改
	int* const p2 = &a;
	//p2 = &b; //错误
	*p2 = 100; //正确

	//const既修饰指针又修饰常量
	const int* const p3 = &a;
	//p3 = &b; //错误
	//*p3 = 100; //错误

	system("pause");

	return 0;
}
#pragma endregion

int FuncPointer(void)
{
   //分配内存空间 malloc
   //已分配的内存，新分配大小 realloc
   //calloc 数组元素个数，每个元素的内存大小
   //free 释放堆内存空间
 int length=10;
int *arr=malloc(sizeof(int)*length);
 if(arr!=NULL)
 {
   for(int i=0;i<length;i++)
   {
       arr[i]=20;
   }
 }
 int *p=realloc(arr,sizeof(int)*(length));
 if(null!=p) arr=p;
 
 int *nn=calloc(10,sizeof(int));
 return 0;
}

